﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
#include<string.h>
#include<algorithm>
#include<list>

using namespace std;

namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator begin() const
		{
			return _str;
		}
		const_iterator end() const
		{
			return _str + _size;
		}
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str)-构造" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 拷贝构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}

		// 移动构造 
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		}
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 拷贝赋值" <<
				endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}
			return *this;
		}

		// 移动赋值 
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}
		~string()
		{
			cout << "~string() -- 析构" << endl;
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				if (_str)
				{
					strcpy(tmp, _str);
					delete[] _str;
				}
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity *
					2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}
		size_t size() const
		{
			return _size;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}

 //int main()
 //{
	// std::list<bit::string> lt;
	// bit::string s1("111111111111111111111");
	// lt.push_back(s1);//左值push_back
	// cout << "*************************" << endl;
	// //右值push_back
	// lt.push_back(bit::string("22222222222222222222222222222"));
	// cout << "*************************" << endl;

	// lt.push_back("3333333333333333333333333333");
	// cout << "*************************" << endl;

	// lt.push_back(move(s1));
	// cout << "*************************" << endl;

	// return 0;
 //}


//// List.h
//// 以下代码为了控制课件篇幅，把跟这⾥⽆关的接⼝都删除了 
//namespace bit
//{
//	template<class T>
//	struct ListNode
//	{
//		ListNode<T>* _next;
//		ListNode<T>* _prev;
//		T _data;
//		ListNode(const T& data = T())
//			:_next(nullptr)
//			, _prev(nullptr)
//			, _data(data)
//		{
//		}
//		ListNode( T&& data)
//			:_next(nullptr)
//			, _prev(nullptr)
//			//x还是左值，move一下强转成右值
//			, _data(move(data))
//		{
//		}
//	};
//	template<class T, class Ref, class Ptr>
//	struct ListIterator
//	{
//		typedef ListNode<T> Node;
//		typedef ListIterator<T, Ref, Ptr> Self;
//		Node* _node;
//		ListIterator(Node* node)
//			:_node(node)
//		{
//		}
//		Self& operator++()
//		{
//			_node = _node->_next;
//			return *this;
//		}
//		Ref operator*()
//		{
//			return _node->_data;
//		}
//		bool operator!=(const Self& it)
//		{
//			return _node != it._node;
//		}
//	};
//	template<class T>
//	class list
//	{
//		typedef ListNode<T> Node;
//	public:
//		typedef ListIterator<T, T&, T*> iterator;
//		typedef ListIterator<T, const T&, const T*> const_iterator;
//		iterator begin()
//		{
//			return iterator(_head->_next);
//		}
//		iterator end()
//		{
//			return iterator(_head);
//		}
//		void empty_init()
//		{
//			_head = new Node();
//			_head->_next = _head;
//			_head->_prev = _head;
//		}
//		list()
//		{
//			empty_init();
//		}
//		void push_back(const T& x)
//		{
//			insert(end(), x);
//		}
//
//		void push_back( T&& x)
//		{
//			//x还是左值，move一下强转成右值
//			insert(end(), move(x));
//		}
//
//		iterator insert(iterator pos, const T& x)
//		{
//			Node* cur = pos._node;
//			Node* newnode = new Node(x);
//			Node* prev = cur->_prev;
//			// prev newnode cur
//			prev->_next = newnode;
//			newnode->_prev = prev;
//			newnode->_next = cur;
//			cur->_prev = newnode;
//			return iterator(newnode);
//		}
//		iterator insert(iterator pos,  T&& x)
//		{
//			Node* cur = pos._node;
//			//x还是左值，move一下强转成右值
//			Node* newnode = new Node(move(x));
//			Node* prev = cur->_prev;
//			// prev newnode cur
//			prev->_next = newnode;
//			newnode->_prev = prev;
//			newnode->_next = cur;
//			cur->_prev = newnode;
//			return iterator(newnode);
//		}
//	private:
//		Node* _head;
//	};
//}
//// Test.cpp
////#include"List.h"
//int main()
//{
//	bit::list<bit::string> lt;
//	cout << "*************************" << endl;
//	bit::string s1("111111111111111111111");
//	lt.push_back(s1);
//	cout << "*************************" << endl;
//	lt.push_back(bit::string("22222222222222222222222222222"));
//	cout << "*************************" << endl;
//	lt.push_back("3333333333333333333333333333");
//	cout << "*************************" << endl;
//	lt.push_back(move(s1));
//	cout << "*************************" << endl;
//	return 0;
//}

//// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤ 
//template<class T>
//void f1(T& x)
//{
//}
// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤ 
//template<class T>
//void f2(T&& x)
//{
//}
//int main()
//{
//	int n = 0;
//	// 折叠->实例化为void f2(int&& x) 
//	f2<int&&>(n); // 报错 
//	f2<int&&>(0);
//
//
//
//
//
//
//	//typedef int& lref;
//	//typedef int&& rref;
//	////using rref = int&&;
//	//int n = 0;
//
//	////折叠引用
//	//lref& r1 = n; // r1 的类型是 int& 
//	//lref&& r2 = n; // r2 的类型是 int& 
//	//rref& r3 = n; // r3 的类型是 int& 
//	//rref&& r4 = 1; // r4 的类型是 int&& 
//
//	return 0;
//}

////万能引用
//template<class T>
//void Function(T&& t)
//{
//	int a = 0;
//	T x = a;
//	//x++;
//	cout << &a << endl;
//	cout << &x << endl << endl;
//}
//int main()
//{
//	const int b = 8;
//	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
//	// 所以Function内部会编译报错，x不能++ 
//	Function(std::move(b)); // const 右值 
//
//
//
//	//// b是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t)
//	//// 所以Function内部会编译报错，x不能++ 
//	//Function(b); // const 左值
//
//
//
//	//int a;
//	//// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	//Function(std::move(a)); // 右值 
//
//
//	//// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t) 
//	//Function(a); // 左值 
//
//
//	//// 10是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	//Function(10); // 右值 
//
//
//	//// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	//Function(std::move(a)); // 右值 
//	
//	//const int b = 8;
//	//// a是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t)
//	//// 所以Function内部会编译报错，x不能++ 
//	//Function(b); // const 左值 
//	//// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
//	//// 所以Function内部会编译报错，x不能++ 
//	//Function(std::move(b)); // const 右值 
//	return 0;
//}


//void Fun(int& x) { cout << "左值引用" << endl; }
//void Fun(const int& x) { cout << "const 左值引用" << endl; }
//void Fun(int&& x) { cout << "右值引用" << endl; }
//void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//template<class T>
//
////万能引用
//void Function(T&& t)
//{
//	//让t跟Fun匹配
//	Fun(forward<T&>(t));
//
//}
//
//int main()
//{
//	// 10是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	Function(10); // 右值 
//	int a;
//	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t) 
//	Function(a); // 左值 
//	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	Function(std::move(a)); // 右值 
//	const int b = 8;
//	// b是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t)
//	Function(b); // const 左值 
//	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
//	Function(std::move(b)); // const 右值 
//	return 0;
//}

//int main()
//{
//	//auto add = [](int a, int b)->int {return a + b; };
//	//cout << add(5, 5) << endl;
//
//	//auto add = []
//	//	{
//	//		cout << "您好" << endl;
//	//	};
//	//add();
//
//	int a = 2, b = 5;
//	auto add = [](int& a, int& b)
//		{
//			int tmp = a;
//			a = b;
//			b = tmp;
//		};
//	add(a, b);
//	cout << "a:" << a << " b:" << b << endl;
//
//	return 0;
//}

#include<vector>
#include<algorithm>

struct Goods
{
	string _name; // 名字 
	double _price; // 价格 
	int _evaluate; // 评价 
	// ...
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{
	}
};

int main6()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3}, { "菠萝",1.5,4 } };

	//根据价格排序
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });
	//根据评价排序
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate; });

	return 0;
}




int main2()
{
	int a = 1, b = 3;
	//传值捕捉或传引用捕捉，引用可以修改
	auto add = [&a, &b]
		{
			a++;
			b++;
			int tmp = a + b;
			return tmp;
		};
	cout << add() << endl;

	return 0;
}
int main4()
{


	return 0;
}


//int x = 0;
//// 捕捉列表必须为空，因为全局变量不⽤捕捉就可以⽤，没有可被捕捉的变量 
//auto func1 = []()
//	{
//		x++;
//	};


//int x = 0;
//int main()
//{
//	// 只能⽤当前lambda局部域和捕捉的对象和全局对象 
//	int a = 0, b = 1, c = 2, d = 3;
//
//	// 传值捕捉本质是⼀种拷⻉,并且被const修饰了 
//	// mutable相当于去掉const属性，可以修改了 
//	// 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉ 
//	auto func7 = [=]()mutable
//		{
//			a++;
//			b++;
//			c++;
//			d++;
//			return a + b + c + d;
//		};
//	cout << func7() << endl;
//	cout << a << " " << b << " " << c << " " << d << endl;
//	return 0;
//}



	//// 局部的静态和全局变量不能捕捉，也不需要捕捉 
	//static int m = 2;
	//auto func6 = []
	//	{
	//		int ret = x + m;
	//		return ret;
	//	};

	//cout << func6() << endl;


	//cout << a << " " <<  b << endl;
	//return 0;



class Rate
{
public:
	Rate(double rate)
		: _rate(rate)
	{
	}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};

int main()
{
	double rate = 0.49;
	// lambda
	auto r2 = [rate](double money, int year) {
		return money * rate * year;
		};
	// 函数对象 
	Rate r1(rate);
	cout << r1(10000, 2) << endl;
	cout << r2(10000, 2) << endl;

	auto func1 = [] {
		cout << "hello world" << endl;
		};
	func1();
	return 0;
}